// 配置文件 - 管理API密钥和其他设置
class ConfigManager {
    constructor() {
        this.config = {
            apiKey: '',
            isConfigured: false,
            model: 'moonshot-v1-8k',
            maxTokens: 4000,
            autoTranslate: true,
            autoSummarize: true,
            theme: 'light',
            // 多服务商配置
            providers: {
                moonshot: {
                    apiKey: '',
                    baseUrl: 'https://api.moonshot.cn/v1',
                    configured: false
                },
                openai: {
                    apiKey: '',
                    baseUrl: 'https://api.openai.com/v1',
                    configured: false
                },
                anthropic: {
                    apiKey: '',
                    baseUrl: 'https://api.anthropic.com',
                    configured: false
                }
            }
        };
        this.init();
    }
    
    async init() {
        await this.loadConfig();
    }
    
    // 加载配置
    async loadConfig() {
        try {
            const result = await chrome.storage.local.get([
                'apiKey', 
                'isConfigured', 
                'model', 
                'maxTokens', 
                'autoTranslate', 
                'autoSummarize', 
                'theme',
                'providers'
            ]);
            
            // 合并配置，确保providers结构完整
            this.config = { ...this.config, ...result };
            
            // 确保providers配置完整性
            if (!this.config.providers) {
                this.config.providers = {
                    moonshot: {
                        apiKey: this.config.apiKey || '', // 向后兼容
                        baseUrl: 'https://api.moonshot.cn/v1',
                        configured: !!this.config.apiKey
                    },
                    openai: {
                        apiKey: '',
                        baseUrl: 'https://api.openai.com/v1',
                        configured: false
                    },
                    anthropic: {
                        apiKey: '',
                        baseUrl: 'https://api.anthropic.com',
                        configured: false
                    }
                };
            }
            
            console.log('配置加载成功:', this.config);
            return this.config;
        } catch (error) {
            console.error('加载配置失败:', error);
            return this.config;
        }
    }
    
    // 保存配置
    async saveConfig(newConfig = {}) {
        try {
            // 合并新配置
            this.config = { ...this.config, ...newConfig };
            
            // 保存到Chrome存储
            await chrome.storage.local.set(this.config);
            
            console.log('配置保存成功:', this.config);
            return true;
        } catch (error) {
            console.error('保存配置失败:', error);
            return false;
        }
    }
    
    // 获取API密钥
    getApiKey() {
        console.log('获取API密钥:', this.config.apiKey ? '***' + this.config.apiKey.slice(-4) : '未设置');
        return this.config.apiKey;
    }
    
    // 设置API密钥
    async setApiKey(apiKey) {
        return await this.saveConfig({ 
            apiKey: apiKey.trim(), 
            isConfigured: !!apiKey.trim() 
        });
    }
    
    // 检查是否已配置
    isConfigured() {
        // 检查是否有至少一个服务商已配置
        if (this.config.providers) {
            const hasConfiguredProvider = Object.values(this.config.providers).some(p => p.configured && p.apiKey);
            return hasConfiguredProvider;
        }
        // 向后兼容检查
        return this.config.isConfigured && !!this.config.apiKey;
    }
    
    // 获取模型设置
    getModel() {
        return this.config.model;
    }
    
    // 设置模型
    async setModel(model) {
        return await this.saveConfig({ model });
    }
    
    // 获取最大token数
    getMaxTokens() {
        return this.config.maxTokens;
    }
    
    // 设置最大token数
    async setMaxTokens(maxTokens) {
        return await this.saveConfig({ maxTokens });
    }
    
    // 获取自动翻译设置
    getAutoTranslate() {
        return this.config.autoTranslate;
    }
    
    // 设置自动翻译
    async setAutoTranslate(autoTranslate) {
        return await this.saveConfig({ autoTranslate });
    }
    
    // 获取自动总结设置
    getAutoSummarize() {
        return this.config.autoSummarize;
    }
    
    // 设置自动总结
    async setAutoSummarize(autoSummarize) {
        return await this.saveConfig({ autoSummarize });
    }
    
    // 获取主题设置
    getTheme() {
        return this.config.theme;
    }
    
    // 设置主题
    async setTheme(theme) {
        return await this.saveConfig({ theme });
    }
    
    // 重置配置
    async resetConfig() {
        try {
            await chrome.storage.local.clear();
            this.config = {
                apiKey: '',
                isConfigured: false,
                model: 'moonshot-v1-8k',
                maxTokens: 4000,
                autoTranslate: true,
                autoSummarize: true,
                theme: 'light',
                providers: {
                    moonshot: {
                        apiKey: '',
                        baseUrl: 'https://api.moonshot.cn/v1',
                        configured: false
                    },
                    openai: {
                        apiKey: '',
                        baseUrl: 'https://api.openai.com/v1',
                        configured: false
                    },
                    anthropic: {
                        apiKey: '',
                        baseUrl: 'https://api.anthropic.com',
                        configured: false
                    }
                }
            };
            console.log('配置已重置');
            return true;
        } catch (error) {
            console.error('重置配置失败:', error);
            return false;
        }
    }
    
    // 导出配置
    exportConfig() {
        const exportData = {
            ...this.config,
            apiKey: this.config.apiKey ? '***' + this.config.apiKey.slice(-4) : '' // 隐藏完整密钥
        };
        
        // 隐藏所有服务商的API密钥
        if (exportData.providers) {
            Object.keys(exportData.providers).forEach(providerName => {
                const provider = exportData.providers[providerName];
                if (provider.apiKey) {
                    provider.apiKey = '***' + provider.apiKey.slice(-4);
                }
            });
        }
        
        return exportData;
    }
    
    // 导入配置
    async importConfig(configData) {
        try {
            // 验证配置数据
            if (!configData || typeof configData !== 'object') {
                throw new Error('无效的配置数据');
            }
            
            // 过滤有效的配置项
            const validConfig = {};
            const validKeys = ['model', 'maxTokens', 'autoTranslate', 'autoSummarize', 'theme'];
            
            for (const key of validKeys) {
                if (configData[key] !== undefined) {
                    validConfig[key] = configData[key];
                }
            }
            
            // 处理providers配置（不导入API密钥以保证安全）
            if (configData.providers) {
                validConfig.providers = {};
                Object.keys(configData.providers).forEach(providerName => {
                    const provider = configData.providers[providerName];
                    if (provider && typeof provider === 'object') {
                        validConfig.providers[providerName] = {
                            baseUrl: provider.baseUrl || this.config.providers[providerName]?.baseUrl || '',
                            apiKey: '', // 不导入API密钥
                            configured: false
                        };
                    }
                });
            }
            
            // 保存配置
            await this.saveConfig(validConfig);
            console.log('配置导入成功');
            return true;
        } catch (error) {
            console.error('导入配置失败:', error);
            return false;
        }
    }
    
    // 验证API密钥格式
    validateApiKey(apiKey) {
        if (!apiKey || typeof apiKey !== 'string') {
            return { valid: false, message: 'API密钥不能为空' };
        }
        
        const trimmedKey = apiKey.trim();
        if (trimmedKey.length === 0) {
            return { valid: false, message: 'API密钥不能为空' };
        }
        
        // 检查是否包含空格
        if (trimmedKey.includes(' ')) {
            return { valid: false, message: 'API密钥不能包含空格' };
        }
        
        // 检查长度（Kimi API密钥通常较长）
        if (trimmedKey.length < 10) {
            return { valid: false, message: 'API密钥长度不足' };
        }
        
        return { valid: true, message: 'API密钥格式正确' };
    }
    
    // 测试API密钥
    async testApiKey(apiKey) {
        try {
            // 通过background script发起API测试请求
            const response = await chrome.runtime.sendMessage({
                type: 'TEST_API_KEY',
                data: { apiKey: apiKey }
            });
            
            if (response && response.success) {
                return { valid: true, message: 'API密钥验证成功' };
            } else {
                return { valid: false, message: response.error || 'API密钥无效或已过期' };
            }
        } catch (error) {
            console.error('测试API密钥失败:', error);
            return { valid: false, message: '网络连接失败，请检查网络设置' };
        }
    }
}

// 创建全局配置管理器实例
window.configManager = new ConfigManager(); 